package com.ip.user.service.impl;

import com.ip.user.mapper.*;
import com.ip.user.models.vo.*;
import com.ip.user.models.service.PermissionService;
import com.ip.user.models.service.SysUserService;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 权限服务实现类
 */
@DubboService
@Service
public class PermissionServiceImpl implements PermissionService {
    
    @Autowired
    private SysUserGroupRelMapper userGroupRelMapper;
    
    @Autowired
    private SysGroupPermRelMapper groupPermRelMapper;
    
    @Autowired
    private SysPermissionMapper permissionMapper;
    
    @Autowired
    private SysUserGroupMapper userGroupMapper;
    
    @Autowired
    private SysUserService sysUserService;
    
    /**
     * 获取用户的所有权限编码
     * @param userId 用户ID
     * @return 权限编码集合
     */
    @Override
    public Set<String> getUserPermissions(Integer userId) {
        Set<String> permissions = new HashSet<>();
        
        // 获取用户所属的用户组
        List<SysUserGroupVO> userGroups = userGroupMapper.selectUserGroupsByUserId(userId);
        
        // 获取用户组对应的权限
        for (SysUserGroupVO group : userGroups) {
            List<SysPermissionVO> groupPermissions = permissionMapper.selectPermissionsByGroupId(group.getGroupId());
            for (SysPermissionVO perm : groupPermissions) {
                permissions.add(perm.getPermCode());
            }
        }
        
        return permissions;
    }
    
    /**
     * 检查用户是否具有指定权限
     * @param userId 用户ID
     * @param permissionCode 权限编码
     * @return 是否具有权限
     */
    @Override
    public boolean hasPermission(Integer userId, String permissionCode) {
        // 检查用户组权限
        List<String> groupPerms = permissionMapper.selectPermissionCodesByUserId(userId);
        return groupPerms.contains(permissionCode);
    }
    
    /**
     * 获取用户所属的所有用户组
     * @param userId 用户ID
     * @return 用户组列表
     */
    @Override
    public List<SysUserGroupVO> getUserGroups(Integer userId) {
        return userGroupMapper.selectUserGroupsByUserId(userId);
    }
    
    /**
     * 获取用户组的所有权限
     * @param groupId 用户组ID
     * @return 权限列表
     */
    @Override
    public List<SysPermissionVO> getGroupPermissions(Integer groupId) {
        return permissionMapper.selectPermissionsByGroupId(groupId);
    }
    
    /**
     * 为用户组分配权限
     * @param groupId 用户组ID
     * @param permId 权限ID
     * @return 是否分配成功
     *
    @Override
    public boolean assignPermissionToGroup(Integer groupId, Integer permId) {
        // 检查关系是否已存在
        SysGroupPermRelVO existingRel = groupPermRelMapper.selectGroupPermRel(groupId, permId);
        if (existingRel != null) {
            return true; // 关系已存在
        }
        
        // 创建新的关系
        SysGroupPermRelVO rel = new SysGroupPermRelVO();
        rel.setGroupId(groupId);
        rel.setPermId(permId);
        int result = groupPermRelMapper.insertGroupPermRel(rel);
        return result > 0;
    }
    */
    
    /**
     * 为用户组设置权限（先删除所有权限，再重新分配）
     * @param groupId 用户组ID
     * @param permIds 权限ID列表
     * @return 是否设置成功
     */
    @Override
    public boolean setGroupPermissions(Integer groupId, List<Integer> permIds) {
        // 删除用户组当前所有权限关系
        List<SysGroupPermRelVO> existingRels = groupPermRelMapper.selectGroupPermRelsByGroupId(groupId);
        for (SysGroupPermRelVO rel : existingRels) {
            groupPermRelMapper.deleteGroupPermRel(rel.getRelId());
        }
        
        // 如果权限ID列表为null或空，表示只需要移除所有权限
        if (permIds == null || permIds.isEmpty()) {
            return true;
        }
        
        // 为每个权限创建新的关系
        for (Integer permId : permIds) {
            SysGroupPermRelVO rel = new SysGroupPermRelVO();
            rel.setGroupId(groupId);
            rel.setPermId(permId);
            groupPermRelMapper.insertGroupPermRel(rel);
        }
        return true;
    }
    
    /**
     * 设置用户的用户组（先移除用户当前所有用户组，再添加到指定用户组）
     * @param userId 用户ID
     * @param groupIds 用户组ID列表，如果为null或空列表则表示移除所有用户组
     * @return 是否设置成功
     */
    @Override
    public boolean setUserGroups(Integer userId, List<Integer> groupIds) {
        // 删除用户当前所有用户组关系
        userGroupRelMapper.deleteUserGroupRelByUserId(userId);
        
        // 如果用户组ID列表为null或空，表示只需要移除所有用户组
        if (groupIds == null || groupIds.isEmpty()) {
            return true;
        }
        
        // 为每个用户组创建新的关系
        for (Integer groupId : groupIds) {
            SysUserGroupRelVO rel = new SysUserGroupRelVO();
            rel.setUserId(userId);
            rel.setGroupId(groupId);
            userGroupRelMapper.insertUserGroupRel(rel);
        }
        return true;
    }
    
    /**
     * 为用户分配班级特定权限
     * @param userId 用户ID
     * @param classId 班级ID
     * @param permCode 权限编码
     * @return 是否分配成功
     *
    @Override
    public boolean assignClassPermissionToUser(Integer userId, Integer classId, String permCode) {
        // 检查权限是否已存在
        SysUserClassPermVO existingPerm = userClassPermMapper.selectUserClassPerm(userId, classId, permCode);
        if (existingPerm != null) {
            return true; // 权限已存在
        }
        
        // 创建新的权限记录
        SysUserClassPermVO perm = new SysUserClassPermVO();
        perm.setUserId(userId);
        perm.setClassId(classId);
        perm.setPermCode(permCode);
        int result = userClassPermMapper.insertUserClassPerm(perm);
        return result > 0;
    }
    */
    /**
     * 获取所有用户组（仅管理员可用）
     * @param userId 用户ID（用于验证管理员权限）
     * @return 所有用户组列表
     */
    @Override
    public List<SysUserGroupVO> getAllUserGroups(Integer userId) {
        // 验证是否为管理员
        UserVO user = sysUserService.getUserById(userId);
        if (user == null || user.getIsStudentAdmin() == null || user.getIsStudentAdmin() != 1) {
            throw new RuntimeException("只有管理员可以获取所有用户组");
        }
        
        // 返回所有用户组
        return userGroupMapper.selectAllUserGroups();
    }
    
    /**
     * 获取所有权限列表
     * @return 所有权限列表
     */
    @Override
    public List<SysPermissionVO> getAllPermissions() {
        return permissionMapper.selectAllPermissions();
    }
}